package com.tedu.api;

import org.junit.Test;

import java.util.concurrent.Callable;

/**
 * Java万物皆对象，，对象皆可new---->真的面向对象-->不完全是【八大基本数据类型不是】
 * 对象【类--创建对象，调用属性，方法】
 * 8个基础数据类型---本质类型---类---包装类【对象，通过点调用方法，属性】
 *包装类不可以修改：final修饰类，无法继承
 * 八个包装类的方法基本是通用
 *
 *      int         Integer          java.lang     继承Number
 *      long        Long             java.lang     继承Number
 *      double      Double           java.lang     继承Number
 *      short       Short            java.lang     继承Number
 *      float       Float            java.lang     继承Number
 *      byte        Byte             java.lang     继承Number
 *      char        Character        java.lang     继承Object
 *      boolean     Boolean          java.lang     继承Object
 *
 */
public class Packing {
    @Test
    public void test(){
        int i=1; //不是面向对象的
        //面向对象
        Integer a=new Integer(i);
        a.toString();
    }
    /**
     * 包装类API
     * 抽象类  Number  父类：Integer、Long、Double、Short、Float、Byte
     * xxxValue抽象方法：把基本数据类型转换成包装类的方法
     * intValue方法    返回int变量
     * LongValue方法   返回long变量
     * doubleValue方法  返回double变量
     * shortValue方法   返回short变量
     * floatValue方法    返回float变量
     * byteValue方法    返回byte变量
     * 需求：把以上的6个数据类型，转换包装类，输出基本数据类型
     *
     */
    @Test
    public void testValue(){
        //int打包---包装类---取包----从包装类获取基础数据类型
        Integer i=new Integer("123");
        int is=i.intValue();
        Integer t=new Integer("123");
        int si=t.intValue();
        System.out.println((is==si));
        //==对比  值
        System.out.println(i.equals(t));
        //.equals  对比对象   确定对象是否有值【包装类--实际值】  有实际值  对比
    }
    //其他五个基础数据类型的包装类--打包  拆包
    @Test
    public void testMain(){
        Long l=new Long("123");
        long l1=l.longValue();
        Long o=new Long("123");
        long l2=o.longValue();
        System.out.println((l1==l2));
        System.out.println(l.equals(o));

        Double d=new  Double("123");
        double d1=l.doubleValue();
        Double u=new  Double("123");
        double d2=o.doubleValue();
        System.out.println((d1==d2));
        System.out.println(d.equals(u));

        Short s=new  Short("123");
        short s1=l.shortValue();
        Short h=new Short("123");
        short s2=o.shortValue();
        System.out.println((s1==s2));
        System.out.println(s.equals(h));
    }
    /**
     * xxxValue抽象方法-----6个基础类型的包装类
     *                    包装类.valueOf("对应类型")
     *                    静态方法【打包，拆包】
     * 打包：对应包装类中存在对应的类型
     * 拆包：对应包装类，类型，取出
     */
    @Test
    public void testValueOf(){
      int  i=Integer.valueOf("123");        //类名点出来：静态方法【Number抽象类】
      double d=Double.valueOf("123.123");
      boolean b=Boolean.valueOf("true");
      char c=Character.valueOf('i');
      float f=Float.valueOf("1");
      short s=Short.valueOf("2");
      byte b1=Byte.valueOf("");
    }
    /**
     * parseXXX       静态方法【重点：Servlet JavaWeb】
     * 作用：将字符串转换为对应的类型：
     * 参数传递--字符串---给字符串转换为对应数据类型
     * 注意：字符串随便写，不可以随便解析成对应类型
     *
     */
    @Test
    public void testParseXXX(){
        //1.把基本数据类型转换为字符串方法 2 转换为字符串
        String s=String.valueOf("2");
        //2.把字符串转换为基础数据类型方法   需要解析出来
        String s2="2";
        System.out.println(s2+"打桩");
        int i=Integer.parseInt(s2);


        String s3="123.123";
        System.out.println(s3);
        double d=Double.parseDouble(s3);

        String s4="true";
        System.out.println(s4);
        boolean b=Boolean.parseBoolean(s4);

        String s5="10L";  //无法加L表示long！  符合三种类型： Integer  byte    short
        System.out.println(s5);
        long  l=Long.parseLong(s5);

        String s6="a";
        System.out.println(s6); //Character  字符类型包装类：无法解析
        //总结：1.字符类，无法正确的解析成对应类型，不存在char字符
        //     2.字面量L/F，认为这是一个字符串，解析失败
    }
    /**
     * 包装类   自动拆装箱
     * JDK1.5   新特性
     * JDK1.5之前没有自动拆装箱
     */
    @Test
    public void test01(){
        //JDK1.5
        Integer in=Integer.valueOf("1");  //输入类型转换为Integer
        int i=in.intValue();  //把包装好的类型，基础数据类型取出
        //JDK1.5 之后  定义方法编译器认可，，并非JVM虚拟机认可！
        Integer it=1;//装箱
        int is=it;   //拆箱
        //自动拆装箱实际上，把拆箱与装箱的步骤交给idea执行
    }
}
